﻿//#include "GNSSSatPos.h"
//#include "CoordSys.h"
//#include "SatelliteEphemeris.h"
//#include "ReadNavFile.h"
//#include <iostream>
//#include <iomanip>
//
//int main() {
//    try {
//        // 1. 读取导航文件
//        std::string navFilePath = "1234560660442.txt";  // 替换为实际文件路径
//        NavigationReader navReader(navFilePath);
//        if (!navReader.readFile()) {
//          std::cerr << "导航文件读取失败，程序退出！" << std::endl;
//           return 1;
//        }
//
//        // 2. 解析星历数据
//        auto ephemerisList = navReader.getParsedEphemeris();
//        std::cout << "解析到星历数量: " << ephemerisList.size() << std::endl;
//
//        // 3. 选择目标卫星（示例 PRN 为 "C01"，可根据实际数据调整）
//        std::string targetPRN = "C01";
//        SatelliteEphemeris targetEphemeris = EphemerisParser::findEphemerisByPRN(ephemerisList, targetPRN);
//
//       // 4. 输出卫星基本参数
//        std::cout << "\n=== " << targetPRN << " 卫星参数 ===" << std::endl;
//       std::cout << std::fixed << std::setprecision(6);
//        std::cout << "时间: " << targetEphemeris.year << "-"
//            << std::setw(2) << std::setfill('0') << targetEphemeris.month << "-"
//            << std::setw(2) << targetEphemeris.day << " "
//            << std::setw(2) << targetEphemeris.hour << ":"
//           << std::setw(2) << targetEphemeris.minute << ":"
//            << std::setw(9) << targetEphemeris.second << std::endl;
//
//        std::cout << "钟差参数: "
//            << "a0=" << targetEphemeris.clockBias << ", "
//            << "a1=" << targetEphemeris.clockDrift << ", "
//            << "a2=" << targetEphemeris.clockAccel << std::endl;
//
//        std::cout << "轨道参数: "
//            << "sqrtA=" << targetEphemeris.sqrtSemiMajor << ", "
//            << "e=" << targetEphemeris.eccentricity << ", "
//            << "M0=" << targetEphemeris.meanAnomaly << std::endl;
//
//        // 5. 计算卫星位置（使用星历参考时刻作为传播时间示例，可按需替换）
//        double transmitTime = targetEphemeris.ephemerisTime;
//       CartesianPoint satPosition = SatelliteOrbitCalculator::calculateSatPosition(targetEphemeris, transmitTime);
//
//        // 6. 输出卫星位置信息
//        std::cout << "\n=== 卫星位置（笛卡尔坐标） ===" << std::endl;        std::cout << std::scientific << std::setprecision(3);
//        std::cout << "X: " << satPosition.x << " m" << std::endl;
//        std::cout << "Y: " << satPosition.y << " m" << std::endl;
//        std::cout << "Z: " << satPosition.z << " m" << std::endl;
//
//        std::cout << "地心距离: " << satPosition.magnitude() << " m" << std::endl;
//
//        // 7. 坐标转换示例（大地坐标与 ENU 坐标，需传入参考点，这里简单用原点演示，实际应按需替换）
//        CoordinateConverter coordConverter(CoordinateSystemType::WGS84);
//        GeodeticCoord geodeticCoord = coordConverter.cartesianToGeodetic(satPosition);
//        std::cout << "\n=== 转换为大地坐标 ===" << std::endl;
//        std::cout << std::fixed << std::setprecision(6);
//        std::cout << "纬度（弧度）: " << geodeticCoord.latitude << ", "
//            << "经度（弧度）: " << geodeticCoord.longitude << ", "
//            << "高度（米）: " << geodeticCoord.height << std::endl;
//
//       CartesianPoint refPoint;  // 参考点设为原点示例，实际应替换为真实参考点
//        LocalENU enuCoord = coordConverter.cartesianToLocalENU(satPosition, refPoint);
//        std::cout << "\n=== 转换为局部ENU坐标 ===" << std::endl;
//        std::cout << "东向: " << enuCoord.east << " m, "
//           << "北向: " << enuCoord.north << " m, "
//            << "天向: " << enuCoord.up << " m" << std::endl;
//
//    }
//    catch (const std::exception& e) {
//       std::cerr << "程序运行出错: " << e.what() << std::endl;
//       return 1;
//    }
//
//    return 0;
//}
//#include <iostream>
//#include <iomanip>
//#include <ctime>
//#include "IonosphereCorrection.h"
//#include "TroposphereCorrection.h"
//#include "CoordinateConverter.h"
//#include "SatellitePosition.h"
//
//int main() {
//    // 设置测试数据
//    CartesianCoord receiverCoord = { -2091342.6543, 4800418.4462, 3629758.3665 };
//
//    // 卫星坐标（示例值，实际应用中需要通过卫星位置类计算）
//    CartesianCoord satelliteCoord = { -32348377, 27042006, 509548 };
//
//    // 转换接收机坐标为大地坐标
//    GeodeticCoord receiverGeoCoord = CoordinateConverter::cartesianToGeodetic(receiverCoord);
//
//    // 设置观测时间
//    std::tm obsTime = {};
//    obsTime.tm_year = 2017 - 1900;  // 年份从1900开始计算
//    obsTime.tm_mon = 3 - 1;         // 月份从0开始计算
//    obsTime.tm_mday = 7;
//    obsTime.tm_hour = 5;
//    obsTime.tm_min = 6;
//    obsTime.tm_sec = 35;
//
//    // 计算卫星高度角
//    double elevation = CoordinateConverter::calculateSatelliteElevation(receiverCoord, satelliteCoord);
//
//    // 创建电离层和对流层改正类实例
//    IonosphereCorrection ionoCorrection;
//    TroposphereCorrection tropoCorrection;
//
//    // 计算电离层延迟改正
//    double ionoDelay = ionoCorrection.calculateCorrection(
//        receiverGeoCoord, satelliteCoord, obsTime);
//
//    // 计算对流层延迟改正
//    double tropoDelay = tropoCorrection.calculateCorrection(
//        elevation, receiverGeoCoord, obsTime);
//
//    // 输出结果
//    std::cout << std::fixed << std::setprecision(6);
//    std::cout << "C01伪距观测值的电离层和对流层延迟误差改正值:" << std::endl;
//    std::cout << "观测时间: " << 2017 << "-" << 3 << "-" << 7
//        << " " << 5 << ":" << 6 << ":" << 35 << std::endl;
//    std::cout << "接收机坐标 (XYZ): "
//        << receiverCoord.x << ", "
//        << receiverCoord.y << ", "
//        << receiverCoord.z << " (米)" << std::endl;
//    std::cout << "卫星坐标 (XYZ): "
//        << satelliteCoord.x << ", "
//        << satelliteCoord.y << ", "
//        << satelliteCoord.z << " (米)" << std::endl;
//    std::cout << "卫星高度角: " << elevation << " 度" << std::endl;
//    std::cout << "电离层延迟改正 (Klobuchar模型): " << ionoDelay << " 米" << std::endl;
//    std::cout << "对流层延迟改正 (Saastamoinen模型): " << tropoDelay << " 米" << std::endl;
//
//    return 0;
//}
//int main() {
    // 单点定位数据处理全流程注释说明

    // 第一步：数据准备与读取
    // 1.1 读取O文件（观测值文件）
    // - 解析RINEX格式O文件头，提取观测值类型（C1C,L1C,D1C,S1C等）
    // - 按历元读取卫星观测数据，包括伪距、载波相位、多普勒频移等
    // - 存储为观测值结构体数组，每个历元包含多颗卫星观测值
    //std::vector<EpochObservation> observations = ReadRinexOFile("sample.19o");

    // 1.2 读取N文件（导航电文文件）
    // - 解析RINEX格式N文件头，获取电离层参数、UTC参数等
    // - 解析每颗卫星的导航电文，计算卫星轨道参数（开普勒参数）
    // - 构建卫星星历表，用于后续卫星位置计算
    //SatelliteEphemeris ephemeris = ReadRinexNFile("sample.19n");

    // 第二步：数据预处理
    // 2.1 观测值质量控制
    // - 剔除信噪比过低的观测值（如S1C < 35dB-Hz）
    // - 探测并修复周跳（利用Melbourne-Wübbena组合等方法）
    // - 检查并剔除粗差观测值（如伪距突变超过30m）
    //observations = PreprocessObservations(observations);

    // 2.2 卫星位置计算
    // - 对每个历元的每颗卫星，根据导航电文计算卫星发射时刻
    // - 基于开普勒定律和摄动理论，计算卫星在ECEF坐标系中的位置
    // - 考虑相对论效应修正（时钟误差、引力红移等）
    //std::vector<SatellitePosition> satellitePositions =
        //ComputeSatellitePositions(observations, ephemeris);

    // 第三步：误差修正
    // 3.1 电离层延迟修正（单频用户）
    // - 使用广播电离层模型（Klobuchar模型）修正伪距观测值
    // - 公式：Δion = α₀ + α₁·x + α₂·x² + α₃·x³，其中x与纬度、地方时相关
    //ApplyIonosphericCorrection(observations, satellitePositions, ephemeris);

    // 3.2 对流层延迟修正
    // - 使用Saastamoinen模型或Hopfield模型修正对流层延迟
    // - 公式：Δtrop = Δhydro + Δwet，与卫星高度角、气压、温度等相关
    //ApplyTroposphericCorrection(observations, satellitePositions);

    // 3.3 卫星钟差修正
    // - 根据导航电文参数计算卫星钟差并修正
    // - 公式：Δt = a₀ + a₁(t-t₀) + a₂(t-t₀)² + Δtr（相对论修正项）
    //ApplySatelliteClockCorrection(observations, satellitePositions, ephemeris);

    // 第四步：单点定位解算
    // 4.1 构建误差方程（最小二乘模型）
    // - 观测方程：ρ = √[(Xs-Xr)²+(Ys-Yr)²+(Zs-Zr)²] + c·dt + ε
    // - 线性化：v = B·x - l，其中B为设计矩阵，x为待估参数（X,Y,Z,dt）
    // - 迭代求解直至收敛（坐标变化小于1cm）
    //PositionSolution solution = SolveLeastSquares(observations, satellitePositions);

    // 4.2 质量控制与结果评估
    // - 计算残差（观测值与计算值之差）并剔除残差过大的观测值
    // - 计算位置精度因子（PDOP、GDOP等）评估解的几何强度
    // - 输出最终定位结果（大地坐标或平面坐标）
    //EvaluateSolutionQuality(solution);

    // 第五步：结果输出与可视化
    // 5.1 输出定位结果到文件
    //WriteSolutionToFile(solution, "positioning_result.txt");

    // 5.2 可选：可视化定位轨迹
    // - 如果处理多历元数据，可绘制轨迹图展示定位结果变化
   //VisualizePositioningTrajectory(solution);

    //return 0;
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <iomanip>

// 定义常量
const double C = 299792458.0;          // 光速(m/s)
const double OMEGA_EARTH = 7.292115e-5; // 地球自转角速度(rad/s)
const double PI = 3.14159265358979323846;
const double A = 6378137.0;            // 地球长半轴(m)
const double F = 1.0 / 298.257223563;  // 地球扁率

// 卫星系统枚举
enum class SatelliteSystem { BDS };

// 三维向量结构体
struct Vector3 {
    double x, y, z;

    Vector3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}

    // 向量减法
    Vector3 operator-(const Vector3& v) const {
        return Vector3(x - v.x, y - v.y, z - v.z);
    }

    // 向量模长
    double norm() const {
        return std::sqrt(x * x + y * y + z * z);
    }
};

// 观测值结构体
struct Observation {
    std::string prn;            // 卫星编号
    SatelliteSystem system;     // 卫星系统
    double pseudorange;         // 伪距观测值(m)
    double elevation;           // 卫星高度角(rad)
};

// 历元结构体
struct Epoch {
    double time;                // 周内秒
    int week;                   // GPS周
    std::vector<Observation> observations; // 该历元的所有卫星观测值
};

// 卫星星历结构体
struct Ephemeris {
    std::string prn;            // 卫星编号
    double toe;                 // 星历参考时刻(s)
    double toc;                 // 时钟参考时刻(s)
    double af0, af1, af2;       // 卫星钟差参数
    double M0;                  // 平近点角(rad)
    double delta_n;             // 平均运动速度改正数(rad/s)
    double e;                   // 轨道偏心率
    double sqrtA;               // 长半轴平方根(m^0.5)
    double Omega0;              // 升交点赤经(rad)
    double i0;                  // 轨道倾角(rad)
    double omega;               // 近地点角距(rad)
    double Omega_dot;           // 升交点赤经变化率(rad/s)
    double i_dot;               // 轨道倾角变化率(rad/s)
    double Cuc, Cus;            // 纬度幅角调和改正项
    double Crc, Crs;            // 轨道半径调和改正项
    double Cic, Cis;            // 轨道倾角调和改正项
    double Tgd;                 // 群时延差(s)
};

// 单点定位解结构体
struct PositionSolution {
    double X, Y, Z;             // ECEF坐标(m)
    double latitude, longitude; // 大地纬度、经度(rad)
    double height;              // 大地高(m)
    double clockError;          // 接收机钟差(s)
    double pdop;                // 精度因子
};

// 矩阵类(简化版)
class Matrix {
private:
    int rows, cols;
    std::vector<double> data;

public:
    Matrix(int r, int c) : rows(r), cols(c), data(r* c, 0.0) {}

    double& operator()(int i, int j) {
        return data[i * cols + j];
    }

    const double& operator()(int i, int j) const {
        return data[i * cols + j];
    }

    int getRows() const { return rows; }
    int getCols() const { return cols; }

    // 矩阵乘法
    Matrix operator*(const Matrix& other) const {
        Matrix result(rows, other.cols);
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < other.cols; j++) {
                for (int k = 0; k < cols; k++) {
                    result(i, j) += (*this)(i, k) * other(k, j);
                }
            }
        }
        return result;
    }

    // 矩阵转置
    Matrix transpose() const {
        Matrix result(cols, rows);
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                result(j, i) = (*this)(i, j);
            }
        }
        return result;
    }

    // 解线性方程组 Ax = b (简化版高斯消元)
    std::vector<double> solve(const std::vector<double>& b) const {
        // 这里实现简化版的高斯消元法
        // 实际应用中应使用更稳定的算法
        std::vector<double> x = b;
        // ... 高斯消元实现 ...
        return x;
    }
};

// 解析N文件，提取星历数据
std::map<std::string, Ephemeris> parseNFile(const std::string& filename) {
    std::map<std::string, Ephemeris> ephemerides;
    std::ifstream file(filename);
    std::string line;

    if (!file.is_open()) {
        std::cerr << "无法打开N文件: " << filename << std::endl;
        return ephemerides;
    }

    // 跳过文件头
    while (std::getline(file, line)) {
        if (line.find("END OF HEADER") != std::string::npos) {
            break;
        }
    }

    // 解析星历数据
    while (std::getline(file, line)) {
        if (line.empty()) continue;

        Ephemeris eph;
        eph.prn = line.substr(0, 2);

        // 解析时间
        int year, month, day, hour, minute;
        sscanf(line.substr(2, 19).c_str(), "%d %d %d %d %d %d",
            &year, &month, &day, &hour, &minute, &eph.toe);

        // 解析星历参数
        sscanf(line.substr(21).c_str(),
            "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
            &eph.M0, &eph.delta_n, &eph.e, &eph.sqrtA, &eph.Omega0, &eph.i0, &eph.omega,
            &eph.Omega_dot, &eph.i_dot, &eph.Cuc, &eph.Cus, &eph.Crc, &eph.Crs, &eph.Cic, &eph.Cis,
            &eph.af0, &eph.af1, &eph.af2, &eph.Tgd,
            // 忽略剩余未使用的参数
            &eph.toe, &eph.toe, &eph.toe, &eph.toe, &eph.toe, &eph.toe, &eph.toe, &eph.toe, &eph.toe);

        ephemerides[eph.prn] = eph;
    }

    file.close();
    return ephemerides;
}

// 解析O文件，提取观测数据
std::vector<Epoch> parseOFile(const std::string& filename) {
    std::vector<Epoch> epochs;
    // 此处简化实现，实际应根据RINEX O文件格式解析
    // 示例代码仅返回一个包含模拟观测数据的历元
    Epoch epoch;
    epoch.time = 0.0;
    epoch.week = 0;

    // 模拟观测数据(实际应从文件读取)
    Observation obs1 = { "C01", SatelliteSystem::BDS, 25000000.0, 0.5 };
    Observation obs2 = { "C02", SatelliteSystem::BDS, 26000000.0, 0.6 };
    Observation obs3 = { "C03", SatelliteSystem::BDS, 27000000.0, 0.4 };
    Observation obs4 = { "C04", SatelliteSystem::BDS, 28000000.0, 0.3 };

    epoch.observations.push_back(obs1);
    epoch.observations.push_back(obs2);
    epoch.observations.push_back(obs3);
    epoch.observations.push_back(obs4);

    epochs.push_back(epoch);
    return epochs;
}

// 计算卫星位置(ECEF坐标)
Vector3 calculateSatellitePosition(const Ephemeris& eph, double transmitTime) {
    // 计算卫星平均运动速度
    double n0 = sqrt(3.986004418e14 / pow(eph.sqrtA, 6));
    double n = n0 + eph.delta_n;

    // 计算平近点角
    double M = eph.M0 + n * (transmitTime - eph.toe);

    // 迭代计算偏近点角E
    double E = M;
    double E_prev = 0;
    while (fabs(E - E_prev) > 1e-12) {
        E_prev = E;
        E = M + eph.e * sin(E_prev);
    }

    // 计算真近点角
    double sinV = sqrt(1 - pow(eph.e, 2)) * sin(E) / (1 - eph.e * cos(E));
    double cosV = (cos(E) - eph.e) / (1 - eph.e * cos(E));
    double V = atan2(sinV, cosV);

    // 计算纬度幅角
    double u = V + eph.omega;

    // 计算摄动改正
    double CucTerm = eph.Cuc * cos(2 * u);
    double CusTerm = eph.Cus * sin(2 * u);
    double CrcTerm = eph.Crc * cos(2 * u);
    double CrsTerm = eph.Crs * sin(2 * u);
    double CicTerm = eph.Cic * cos(2 * u);
    double CisTerm = eph.Cis * sin(2 * u);

    double du = CucTerm + CusTerm;
    double dr = CrcTerm + CrsTerm;
    double di = CicTerm + CisTerm;

    // 计算校正后的纬度幅角、轨道半径和轨道倾角
    u += du;
    double r = pow(eph.sqrtA, 2) * (1 - eph.e * cos(E)) + dr;
    double i = eph.i0 + eph.i_dot * (transmitTime - eph.toe) + di;

    // 计算卫星在轨道平面内的坐标
    double x = r * cos(u);
    double y = r * sin(u);

    // 计算升交点赤经(考虑地球自转)
    double Omega = eph.Omega0 + (eph.Omega_dot - OMEGA_EARTH) * (transmitTime - eph.toe) - OMEGA_EARTH * eph.toe;

    // 转换到ECEF坐标系
    Vector3 pos;
    pos.x = x * cos(Omega) - y * cos(i) * sin(Omega);
    pos.y = x * sin(Omega) + y * cos(i) * cos(Omega);
    pos.z = y * sin(i);

    return pos;
}

// 计算卫星钟差
double calculateSatelliteClockError(const Ephemeris& eph, double transmitTime) {
    double t = transmitTime - eph.toc;
    double clockError = eph.af0 + eph.af1 * t + eph.af2 * t * t;

    // 相对论效应修正
    double n0 = sqrt(3.986004418e14 / pow(eph.sqrtA, 6));
    double E = 0; // 简化处理，实际需要计算偏近点角
    double epsilon = -4.442807633e-10 * eph.e * pow(eph.sqrtA, 2) * sin(E);
    clockError += epsilon;

    return clockError;
}

// 电离层延迟修正(简化模型)
double ionosphericCorrection(const Observation& obs, const Vector3& satPos,
    const Vector3& recPos) {
    // 简化的电离层修正模型，实际应使用Klobuchar模型
    return 0.0;
}

// 对流层延迟修正(简化模型)
double troposphericCorrection(const Observation& obs, double elevation) {
    // 简化的对流层修正模型，实际应使用Saastamoinen模型
    double tropoDelay = 2.3 / sin(elevation);
    return tropoDelay;
}

// ECEF坐标转大地坐标
void ecefToGeodetic(double X, double Y, double Z, double& lat, double& lon, double& height) {
    double r = sqrt(X * X + Y * Y);
    lon = atan2(Y, X);
    double Esq = 2 * F - F * F;
    double iterLimit = 100;
    double N, theta, lat0 = atan2(Z, r * (1 - F));

    for (int i = 0; i < iterLimit; i++) {
        N = A / sqrt(1 - Esq * sin(lat0) * sin(lat0));
        height = r / cos(lat0) - N;
        lat = atan2(Z + N * Esq * sin(lat0), r);

        if (fabs(lat - lat0) < 1e-9) {
            break;
        }
        lat0 = lat;
    }
}

// 最小二乘法求解单点定位
PositionSolution solveSinglePointPositioning(
    const std::vector<Epoch>& epochs,
    const std::map<std::string, Ephemeris>& ephemerides) {

    PositionSolution solution;
    solution.X = solution.Y = solution.Z = 0.0;
    solution.clockError = 0.0;

    // 初始近似坐标(北京地区近似值)
    double X0 = 4843572.667, Y0 = 1348265.433, Z0 = 4133202.362;
    double dt0 = 0.0;

    // 迭代求解
    for (int iter = 0; iter < 10; iter++) {
        int n = 0;
        for (const auto& epoch : epochs) {
            n += epoch.observations.size();
        }

        if (n < 4) {
            std::cerr << "观测卫星数不足，无法定位" << std::endl;
            return solution;
        }

        // 构建法方程系数矩阵和常数项
        Matrix N(4, 4);
        std::vector<double> U(4, 0.0);

        for (const auto& epoch : epochs) {
            double receiverTime = epoch.time;

            for (const auto& obs : epoch.observations) {
                if (ephemerides.find(obs.prn) == ephemerides.end()) {
                    std::cerr << "未找到卫星 " << obs.prn << " 的星历数据" << std::endl;
                    continue;
                }

                const Ephemeris& eph = ephemerides.at(obs.prn);

                // 估计卫星发射时间
                double transmitTime = receiverTime - obs.pseudorange / C;

                // 计算卫星位置
                Vector3 satPos = calculateSatellitePosition(eph, transmitTime);

                // 计算几何距离
                Vector3 recPos(X0, Y0, Z0);
                Vector3 diff = satPos - recPos;
                double rho = diff.norm();

                // 计算方向余弦
                double dx = satPos.x - X0;
                double dy = satPos.y - Y0;
                double dz = satPos.z - Z0;
                double range = sqrt(dx * dx + dy * dy + dz * dz);

                // 计算观测残差
                double clockError = calculateSatelliteClockError(eph, transmitTime);
                double ionoCorr = ionosphericCorrection(obs, satPos, recPos);
                double tropoCorr = troposphericCorrection(obs, obs.elevation);

                double v = obs.pseudorange - rho - C * dt0 - C * clockError - ionoCorr - tropoCorr;

                // 构建法方程系数矩阵和常数项
                double a[4] = { -dx / range, -dy / range, -dz / range, C };

                for (int i = 0; i < 4; i++) {
                    for (int j = 0; j < 4; j++) {
                        N(i, j) += a[i] * a[j];
                    }
                    U[i] += a[i] * v;
                }
            }
        }

        // 求解法方程
        std::vector<double> dX = N.solve(U);

        // 更新参数
        X0 += dX[0];
        Y0 += dX[1];
        Z0 += dX[2];
        dt0 += dX[3];

        // 判断收敛
        double norm = sqrt(dX[0] * dX[0] + dX[1] * dX[1] + dX[2] * dX[2] + dX[3] * dX[3]);
        if (norm < 1e-6) {
            break;
        }
    }

    // 存储最终解
    solution.X = X0;
    solution.Y = Y0;
    solution.Z = Z0;
    solution.clockError = dt0;

    // ECEF坐标转大地坐标
    ecefToGeodetic(X0, Y0, Z0, solution.latitude, solution.longitude, solution.height);

    // 计算PDOP(简化方法)
    solution.pdop = 1.0;

    return solution;
}

int main() {
    // 读取N文件和O文件
    std::string nFileName = "1234560660442.17N";
    std::string oFileName = "1234560660442.17O";

    std::cout << "正在解析导航电文文件(" << nFileName << ")..." << std::endl;
    std::map<std::string, Ephemeris> ephemerides = parseNFile(nFileName);

    std::cout << "正在解析观测文件(" << oFileName << ")..." << std::endl;
    std::vector<Epoch> epochs = parseOFile(oFileName);

    if (ephemerides.empty()) {
        std::cerr << "错误：未解析到有效星历数据！" << std::endl;
        return 1;
    }

    if (epochs.empty()) {
        std::cerr << "错误：未解析到有效观测数据！" << std::endl;
        return 1;
    }

    std::cout << "解析完成，开始单点定位计算..." << std::endl;

    // 执行单点定位
    PositionSolution solution = solveSinglePointPositioning(epochs, ephemerides);

    // 输出结果
    std::cout << std::fixed << std::setprecision(6);
    std::cout << "\n===== 单点定位计算结果 =====" << std::endl;
    std::cout << "ECEF坐标:" << std::endl;
    std::cout << "X = " << solution.X << " m" << std::endl;
    std::cout << "Y = " << solution.Y << " m" << std::endl;
    std::cout << "Z = " << solution.Z << " m" << std::endl;

    std::cout << "\n大地坐标:" << std::endl;
    std::cout << "纬度 = " << solution.latitude * 180.0 / PI << "°" << std::endl;
    std::cout << "经度 = " << solution.longitude * 180.0 / PI << "°" << std::endl;
    std::cout << "高度 = " << solution.height << " m" << std::endl;

    std::cout << "\n接收机钟差 = " << solution.clockError * C << " m ("
        << solution.clockError * 1e9 << " ns)" << std::endl;

    std::cout << "\n精度因子:" << std::endl;
    std::cout << "PDOP = " << solution.pdop << std::endl;

    std::cout << "\n定位完成！" << std::endl;

    return 0;
}     